<?php
/*=======================================================================
 // File:        JPGRAPH_POLAR.PHP
 // Description: Polar plot extension for JpGraph
 // Created:     2003-02-02
 // Ver:         $Id: jpgraph_polar.php 1796 2009-09-07 09:37:19Z ljp $
 //
 // Copyright (c) Aditus Consulting. All rights reserved.
 //========================================================================
 */

require_once ('jpgraph_plotmark.inc.php');
require_once "jpgraph_log.php";


define('POLAR_360',1);
define('POLAR_180',2);

//
// Note. Don't attempt to make sense of this code.
// In order not to have to be able to inherit the scaling code
// from the main graph package we have had to make some "tricks" since
// the original scaling and axis was not designed to do what is
// required here.
// There were two option. 1: Re-implement everything and get a clean design
// and 2: do some "small" trickery and be able to inherit most of
// the functionlity from the main graph package.
// We choose 2: here in order to save some time.
//

//--------------------------------------------------------------------------
// class PolarPlot
//--------------------------------------------------------------------------
class PolarPlot {
	public $line_style='solid',$mark;
	public $legendcsimtarget='';
	public $legendcsimalt='';
	public $legend="";
	public $csimtargets=array(); // Array of targets for CSIM
	public $csimareas="";   // Resultant CSIM area tags
	public $csimalts=null;   // ALT:s for corresponding target
	public $scale=null;
	private $numpoints=0;
	private $iColor='navy',$iFillColor='';
	private $iLineWeight=1;
	private $coord=null;

	function __construct($aData) {
		$n = count($aData);
		if( $n & 1 ) {
			JpGraphError::RaiseL(17001);
			//('Polar plots must have an even number of data point. Each data point is a tuple (angle,radius).');
		}
		$this->numpoints = $n/2;
		$this->coord = $aData;
		$this->mark = new PlotMark();
	}

	function SetWeight($aWeight) {
		$this->iLineWeight = $aWeight;
	}

	function SetColor($aColor){
		$this->iColor = $aColor;
	}

	function SetFillColor($aColor){
		$this->iFillColor = $aColor;
	}

	function Max() {
		$m = $this->coord[1];
		$i=1;
		while( $i < $this->numpoints ) {
			$m = max($m,$this->coord[2*$i+1]);
			++$i;
		}
		return $m;
	}
	// Set href targets for CSIM
	function SetCSIMTargets($aTargets,$aAlts=null) {
		$this->csimtargets=$aTargets;
		$this->csimalts=$aAlts;
	}

	// Get all created areas
	function GetCSIMareas() {
		return $this->csimareas;
	}

	function SetLegend($aLegend,$aCSIM="",$aCSIMAlt="") {
		$this->legend = $aLegend;
		$this->legendcsimtarget = $aCSIM;
		$this->legendcsimalt = $aCSIMAlt;
	}

	// Private methods

	function Legend($aGraph) {
		$color = $this->iColor ;
		if( $this->legend != "" ) {
			if( $this->iFillColor!='' ) {
				$color = $this->iFillColor;
				$aGraph->legend->Add($this->legend,$color,$this->mark,0,
				$this->legendcsimtarget,$this->legendcsimalt);
			}
			else {
				$aGraph->legend->Add($this->legend,$color,$this->mark,$this->line_style,
				$this->legendcsimtarget,$this->legendcsimalt);
			}
		}
	}

	function Stroke($img,$scale) {

		$i=0;
		$p=array();
		$this->csimareas='';
		while($i < $this->numpoints) {
			list($x1,$y1) = $scale->PTranslate($this->coord[2*$i],$this->coord[2*$i+1]);
			$p[2*$i] = $x1;
			$p[2*$i+1] = $y1;

			if( isset($this->csimtargets[$i]) ) {
				$this->mark->SetCSIMTarget($this->csimtargets[$i]);
				$this->mark->SetCSIMAlt($this->csimalts[$i]);
				$this->mark->SetCSIMAltVal($this->coord[2*$i], $this->coord[2*$i+1]);
				$this->mark->Stroke($img,$x1,$y1);
				$this->csimareas .= $this->mark->GetCSIMAreas();
			}
			else {
				$this->mark->Stroke($img,$x1,$y1);
			}

			++$i;
		}

		if( $this->iFillColor != '' ) {
			$img->SetColor($this->iFillColor);
			$img->FilledPolygon($p);
		}
		$img->SetLineWeight($this->iLineWeight);
		$img->SetColor($this->iColor);
		$img->Polygon($p,$this->iFillColor!='');
	}
}

//--------------------------------------------------------------------------
// class PolarAxis
//--------------------------------------------------------------------------
class PolarAxis extends Axis {
	private $angle_step=15,$angle_color='lightgray',$angle_label_color='black';
	private $angle_fontfam=FF_FONT1,$angle_fontstyle=FS_NORMAL,$angle_fontsize=10;
	private $angle_fontcolor = 'navy';
	private $gridminor_color='lightgray',$gridmajor_color='lightgray';
	private $show_minor_grid = false, $show_major_grid = true ;
	private $show_angle_mark=true, $show_angle_grid=true, $show_angle_label=true;
	private $angle_tick_len=3, $angle_tick_len2=3, $angle_tick_color='black';
	private $show_angle_tick=true;
	private $radius_tick_color='black';

	function __construct($img,$aScale) {
		parent::__construct($img,$aScale);
	}

	function ShowAngleDegreeMark($aFlg=true) {
		$this->show_angle_mark = $aFlg;
	}

	function SetAngleStep($aStep) {
		$this->angle_step=$aStep;
	}

	function HideTicks($aFlg=true,$aAngleFlg=true) {
		parent::HideTicks($aFlg,$aFlg);
		$this->show_angle_tick = !$aAngleFlg;
	}

	function ShowAngleLabel($aFlg=true) {
		$this->show_angle_label = $aFlg;
	}

	function ShowGrid($aMajor=true,$aMinor=false,$aAngle=true) {
		$this->show_minor_grid = $aMinor;
		$this->show_major_grid = $aMajor;
		$this->show_angle_grid = $aAngle ;
	}

	function SetAngleFont($aFontFam,$aFontStyle=FS_NORMAL,$aFontSize=10) {
		$this->angle_fontfam = $aFontFam;
		$this->angle_fontstyle = $aFontStyle;
		$this->angle_fontsize = $aFontSize;
	}

	function SetColor($aColor,$aRadColor='',$aAngleColor='') {
		if( $aAngleColor == '' )
		$aAngleColor=$aColor;
		parent::SetColor($aColor,$aRadColor);
		$this->angle_fontcolor = $aAngleColor;
	}

	function SetGridColor($aMajorColor,$aMinorColor='',$aAngleColor='') {
		if( $aMinorColor == '' )
		$aMinorColor = $aMajorColor;
		if( $aAngleColor == '' )
		$aAngleColor = $aMajorColor;

		$this->gridminor_color = $aMinorColor;
		$this->gridmajor_color = $aMajorColor;
		$this->angle_color = $aAngleColor;
	}

	function SetTickColors($aRadColor,$aAngleColor='') {
		$this->radius_tick_color = $aRadColor;
		$this->angle_tick_color = $aAngleColor;
	}

	// Private methods
	function StrokeGrid($pos) {
		$x = round($this->img->left_margin + $this->img->plotwidth/2);
		$this->scale->ticks->Stroke($this->img,$this->scale,$pos);

		// Stroke the minor arcs
		$pmin = array();
		$p = $this->scale->ticks->ticks_pos;
		$n = count($p);
		$i = 0;
		$this->img->SetColor($this->gridminor_color);
		while( $i < $n ) {
			$r = $p[$i]-$x+1;
			$pmin[]=$r;
			if( $this->show_minor_grid ) {
				$this->img->Circle($x,$pos,$r);
			}
			$i++;
		}

		$limit = max($this->img->plotwidth,$this->img->plotheight)*1.4 ;
		while( $r < $limit ) {
			$off = $r;
			$i=1;
			$r = $off + round($p[$i]-$x+1);
			while( $r < $limit && $i < $n ) {
				$r = $off+$p[$i]-$x;
				$pmin[]=$r;
				if( $this->show_minor_grid ) {
					$this->img->Circle($x,$pos,$r);
				}
				$i++;
			}
		}

		// Stroke the major arcs
		if( $this->show_major_grid ) {
			// First determine how many minor step on
			// every major step. We have recorded the minor radius
			// in pmin and use these values. This is done in order
			// to avoid rounding errors if we were to recalculate the
			// different major radius.
			$pmaj = $this->scale->ticks->maj_ticks_pos;
			$p = $this->scale->ticks->ticks_pos;
			if( $this->scale->name == 'lin' ) {
				$step=round(($pmaj[1] - $pmaj[0])/($p[1] - $p[0]));
			}
			else {
				$step=9;
			}
			$n = round(count($pmin)/$step);
			$i = 0;
			$this->img->SetColor($this->gridmajor_color);
			$limit = max($this->img->plotwidth,$this->img->plotheight)*1.4 ;
			$off = $r;
			$i=0;
			$r = $pmin[$i*$step];
			while( $r < $limit && $i < $n ) {
				$r = $pmin[$i*$step];
				$this->img->Circle($x,$pos,$r);
				$i++;
			}
		}

		// Draw angles
		if( $this->show_angle_grid ) {
			$this->img->SetColor($this->angle_color);
			$d = max($this->img->plotheight,$this->img->plotwidth)*1.4 ;
			$a = 0;
			$p = $this->scale->ticks->ticks_pos;
			$start_radius = $p[1]-$x;
			while( $a < 360 ) {
				if( $a == 90 || $a == 270 ) {
					// Make sure there are no rounding problem with
					// exactly vertical lines
					$this->img->Line($x+$start_radius*cos($a/180*M_PI)+1,
					$pos-$start_radius*sin($a/180*M_PI),
					$x+$start_radius*cos($a/180*M_PI)+1,
					$pos-$d*sin($a/180*M_PI));

				}
				else {
					$this->img->Line($x+$start_radius*cos($a/180*M_PI)+1,
					$pos-$start_radius*sin($a/180*M_PI),
					$x+$d*cos($a/180*M_PI),
					$pos-$d*sin($a/180*M_PI));
				}
				$a += $this->angle_step;
			}
		}
	}

	function StrokeAngleLabels($pos,$type) {

		if( !$this->show_angle_label )
		return;

		$x0 = round($this->img->left_margin+$this->img->plotwidth/2)+1;

		$d = max($this->img->plotwidth,$this->img->plotheight)*1.42;
		$a = $this->angle_step;
		$t = new Text();
		$t->SetColor($this->angle_fontcolor);
		$t->SetFont($this->angle_fontfam,$this->angle_fontstyle,$this->angle_fontsize);
		$xright = $this->img->width - $this->img->right_margin;
		$ytop = $this->img->top_margin;
		$xleft = $this->img->left_margin;
		$ybottom = $this->img->height - $this->img->bottom_margin;
		$ha = 'left';
		$va = 'center';
		$w = $this->img->plotwidth/2;
		$h = $this->img->plotheight/2;
		$xt = $x0; $yt = $pos;
		$margin=5;

		$tl  = $this->angle_tick_len ; // Outer len
		$tl2 = $this->angle_tick_len2 ; // Interior len

		$this->img->SetColor($this->angle_tick_color);
		$rot90 = $this->img->a == 90 ;

		if( $type == POLAR_360 ) {

			// Corner angles of the four corners
			$ca1 = atan($h/$w)/M_PI*180;
			$ca2 = 180-$ca1;
			$ca3 = $ca1+180;
			$ca4 = 360-$ca1;
			$end = 360;

			while( $a < $end ) {
				$ca = cos($a/180*M_PI);
				$sa = sin($a/180*M_PI);
				$x = $d*$ca;
				$y = $d*$sa;
				$xt=1000;$yt=1000;
				if( $a <= $ca1 || $a >= $ca4 ) {
					$yt = $pos - $w * $y/$x;
					$xt = $xright + $margin;
					if( $rot90 ) {
						$ha = 'center';
						$va = 'top';
					}
					else {
						$ha = 'left';
						$va = 'center';
					}
					$x1=$xright-$tl2; $x2=$xright+$tl;
					$y1=$y2=$yt;
				}
				elseif( $a > $ca1 && $a < $ca2 ) {
					$xt = $x0 + $h * $x/$y;
					$yt = $ytop - $margin;
					if( $rot90 ) {
						$ha = 'left';
						$va = 'center';
					}
					else {
						$ha = 'center';
						$va = 'bottom';
					}
					$y1=$ytop+$tl2;$y2=$ytop-$tl;
					$x1=$x2=$xt;
				}
				elseif( $a >= $ca2 && $a <= $ca3 ) {
					$yt = $pos + $w * $y/$x;
					$xt = $xleft - $margin;
					if( $rot90 ) {
						$ha = 'center';
						$va = 'bottom';
					}
					else {
						$ha = 'right';
						$va = 'center';
					}
					$x1=$xleft+$tl2;$x2=$xleft-$tl;
					$y1=$y2=$yt;
				}
				else {
					$xt = $x0 - $h * $x/$y;
					$yt = $ybottom + $margin;
					if( $rot90 ) {
						$ha = 'right';
						$va = 'center';
					}
					else {
						$ha = 'center';
						$va = 'top';
					}
					$y1=$ybottom-$tl2;$y2=$ybottom+$tl;
					$x1=$x2=$xt;
				}
				if( $a != 0 && $a != 180 ) {
					$t->Align($ha,$va);
					if( $this->scale->clockwise ) {
						$t->Set(360-$a);
					}
					else {
						$t->Set($a);
					}
					if( $this->show_angle_mark && $t->font_family > 4 ) {
						$a .= SymChar::Get('degree');
					}
					$t->Stroke($this->img,$xt,$yt);
					if( $this->show_angle_tick ) {
						$this->img->Line($x1,$y1,$x2,$y2);
					}
				}
				$a += $this->angle_step;
			}
		}
		else {
			// POLAR_HALF
			$ca1 = atan($h/$w*2)/M_PI*180;
			$ca2 = 180-$ca1;
			$end = 180;
			while( $a < $end ) {
				$ca = cos($a/180*M_PI);
				$sa = sin($a/180*M_PI);
				$x = $d*$ca;
				$y = $d*$sa;
				if( $a <= $ca1 ) {
					$yt = $pos - $w * $y/$x;
					$xt = $xright + $margin;
					if( $rot90 ) {
						$ha = 'center';
						$va = 'top';
					}
					else {
						$ha = 'left';
						$va = 'center';
					}
					$x1=$xright-$tl2; $x2=$xright+$tl;
					$y1=$y2=$yt;
				}
				elseif( $a > $ca1 && $a < $ca2 ) {
					$xt = $x0 + 2*$h * $x/$y;
					$yt = $ytop - $margin;
					if( $rot90 ) {
						$ha = 'left';
						$va = 'center';
					}
					else {
						$ha = 'center';
						$va = 'bottom';
					}
					$y1=$ytop+$tl2;$y2=$ytop-$tl;
					$x1=$x2=$xt;
				}
				elseif( $a >= $ca2 ) {
					$yt = $pos + $w * $y/$x;
					$xt = $xleft - $margin;
					if( $rot90 ) {
						$ha = 'center';
						$va = 'bottom';
					}
					else {
						$ha = 'right';
						$va = 'center';
					}
					$x1=$xleft+$tl2;$x2=$xleft-$tl;
					$y1=$y2=$yt;
				}
				$t->Align($ha,$va);
				if( $this->show_angle_mark && $t->font_family > 4 ) {
					$a .= SymChar::Get('degree');
				}
				$t->Set($a);
				$t->Stroke($this->img,$xt,$yt);
				if( $this->show_angle_tick ) {
					$this->img->Line($x1,$y1,$x2,$y2);
				}
				$a += $this->angle_step;
			}
		}
	}

	function Stroke($pos,$dummy=true) {

		$this->img->SetLineWeight($this->weight);
		$this->img->SetColor($this->color);
		$this->img->SetFont($this->font_family,$this->font_style,$this->font_size);
		if( !$this->hide_line ) {
			$this->img->FilledRectangle($this->img->left_margin,$pos,
			$this->img->width-$this->img->right_margin,
			$pos+$this->weight-1);
		}
		$y=$pos+$this->img->GetFontHeight()+$this->title_margin+$this->title->margin;
		if( $this->title_adjust=="high" ) {
			$this->title->SetPos($this->img->width-$this->img->right_margin,$y,"right","top");
		}
		elseif( $this->title_adjust=="middle" || $this->title_adjust=="center" ) {
			$this->title->SetPos(($this->img->width-$this->img->left_margin-$this->img->right_margin)/2+$this->img->left_margin,
			$y,"center","top");
		}
		elseif($this->title_adjust=="low") {
			$this->title->SetPos($this->img->left_margin,$y,"left","top");
		}
		else {
			JpGraphError::RaiseL(17002,$this->title_adjust);
			//('Unknown alignment specified for X-axis title. ('.$this->title_adjust.')');
		}


		if (!$this->hide_labels) {
			$this->StrokeLabels($pos,false);
		}
		$this->img->SetColor($this->radius_tick_color);
		$this->scale->ticks->Stroke($this->img,$this->scale,$pos);

		//
		// Mirror the positions for the left side of the scale
		//
		$mid = 2*($this->img->left_margin+$this->img->plotwidth/2);
		$n = count($this->scale->ticks->ticks_pos);
		$i=0;
		while( $i < $n ) {
			$this->scale->ticks->ticks_pos[$i] =
			$mid-$this->scale->ticks->ticks_pos[$i] ;
			++$i;
		}

		$n = count($this->scale->ticks->maj_ticks_pos);
		$i=0;
		while( $i < $n ) {
			$this->scale->ticks->maj_ticks_pos[$i] =
			$mid-$this->scale->ticks->maj_ticks_pos[$i] ;
			++$i;
		}

		$n = count($this->scale->ticks->maj_ticklabels_pos);
		$i=1;
		while( $i < $n ) {
			$this->scale->ticks->maj_ticklabels_pos[$i] =
			$mid-$this->scale->ticks->maj_ticklabels_pos[$i] ;
			++$i;
		}

		// Draw the left side of the scale
		$n = count($this->scale->ticks->ticks_pos);
		$yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMinTickAbsSize();


		// Minor ticks
		if( ! $this->scale->ticks->supress_minor_tickmarks ) {
			$i=1;
			while( $i < $n/2 ) {
				$x = round($this->scale->ticks->ticks_pos[$i]) ;
				$this->img->Line($x,$pos,$x,$yu);
				++$i;
			}
		}

		$n = count($this->scale->ticks->maj_ticks_pos);
		$yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMajTickAbsSize();


		// Major ticks
		if( ! $this->scale->ticks->supress_tickmarks ) {
			$i=1;
			while( $i < $n/2 ) {
				$x = round($this->scale->ticks->maj_ticks_pos[$i]) ;
				$this->img->Line($x,$pos,$x,$yu);
				++$i;
			}
		}
		if (!$this->hide_labels) {
			$this->StrokeLabels($pos,false);
		}
		$this->title->Stroke($this->img);
	}
}

class PolarScale extends LinearScale {
	private $graph;
	public $clockwise=false;

	function __construct($aMax,$graph,$aClockwise) {
		parent::__construct(0,$aMax,'x');
		$this->graph = $graph;
		$this->clockwise = $aClockwise;
	}

	function SetClockwise($aFlg) {
		$this->clockwise = $aFlg;
	}

	function _Translate($v) {
		return parent::Translate($v);
	}

	function PTranslate($aAngle,$aRad) {

		$m = $this->scale[1];
		$w = $this->graph->img->plotwidth/2;
		$aRad = $aRad/$m*$w;

		$a = $aAngle/180 * M_PI;
		if( $this->clockwise ) {
			$a = 2*M_PI-$a;
		}

		$x = cos($a) * $aRad;
		$y = sin($a) * $aRad;

		$x += $this->_Translate(0);

		if( $this->graph->iType == POLAR_360 ) {
			$y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
		}
		else {
			$y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
		}
		return array($x,$y);
	}
}

class PolarLogScale extends LogScale {
	private $graph;
	public $clockwise=false;

	function __construct($aMax,$graph,$aClockwise=false) {
		parent::__construct(0,$aMax,'x');
		$this->graph = $graph;
		$this->ticks->SetLabelLogType(LOGLABELS_MAGNITUDE);
		$this->clockwise = $aClockwise;

	}

	function SetClockwise($aFlg) {
		$this->clockwise = $aFlg;
	}

	function PTranslate($aAngle,$aRad) {

		if( $aRad == 0 )
		$aRad = 1;
		$aRad = log10($aRad);
		$m = $this->scale[1];
		$w = $this->graph->img->plotwidth/2;
		$aRad = $aRad/$m*$w;

		$a = $aAngle/180 * M_PI;
		if( $this->clockwise ) {
			$a = 2*M_PI-$a;
		}

		$x = cos( $a ) * $aRad;
		$y = sin( $a ) * $aRad;

		$x += $w+$this->graph->img->left_margin;//$this->_Translate(0);
		if( $this->graph->iType == POLAR_360 ) {
			$y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
		}
		else {
			$y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
		}
		return array($x,$y);
	}
}

class PolarGraph extends Graph {
	public $scale;
	public $axis;
	public $iType=POLAR_360;
	private $iClockwise=false;

	function __construct($aWidth=300,$aHeight=200,$aCachedName="",$aTimeOut=0,$aInline=true) {
		parent::__construct($aWidth,$aHeight,$aCachedName,$aTimeOut,$aInline) ;
		$this->SetDensity(TICKD_DENSE);
		$this->SetBox();
		$this->SetMarginColor('white');
	}

	function SetDensity($aDense) {
		$this->SetTickDensity(TICKD_NORMAL,$aDense);
	}

	function SetClockwise($aFlg) {
		$this->scale->SetClockwise($aFlg);
	}

	function Set90AndMargin($lm=0,$rm=0,$tm=0,$bm=0) {
		$adj = ($this->img->height - $this->img->width)/2;
		$this->SetAngle(90);
		$lm2 = -$adj + ($lm-$rm+$tm+$bm)/2;
		$rm2 = -$adj + (-$lm+$rm+$tm+$bm)/2;
		$tm2 = $adj + ($tm-$bm+$lm+$rm)/2;
		$bm2 = $adj + (-$tm+$bm+$lm+$rm)/2;
		$this->SetMargin($lm2, $rm2, $tm2, $bm2);
		$this->axis->SetLabelAlign('right','center');
	}

	function SetScale($aScale,$rmax=0,$dummy1=1,$dummy2=1,$dummy3=1) {
		if( $aScale == 'lin' ) {
			$this->scale = new PolarScale($rmax,$this,$this->iClockwise);
		}
		elseif( $aScale == 'log' ) {
			$this->scale = new PolarLogScale($rmax,$this,$this->iClockwise);
		}
		else {
			JpGraphError::RaiseL(17004);//('Unknown scale type for polar graph. Must be "lin" or "log"');
		}

		$this->axis = new PolarAxis($this->img,$this->scale);
		$this->SetMargin(40,40,50,40);
	}

	function SetType($aType) {
		$this->iType = $aType;
	}

	function SetPlotSize($w,$h) {
		$this->SetMargin(($this->img->width-$w)/2,($this->img->width-$w)/2,
		($this->img->height-$h)/2,($this->img->height-$h)/2);
	}

	// Private methods
	function GetPlotsMax() {
		$n = count($this->plots);
		$m = $this->plots[0]->Max();
		$i=1;
		while($i < $n) {
			$m = max($this->plots[$i]->Max(),$m);
			++$i;
		}
		return $m;
	}

	function Stroke($aStrokeFileName="") {

		// Start by adjusting the margin so that potential titles will fit.
		$this->AdjustMarginsForTitles();

		// If the filename is the predefined value = '_csim_special_'
		// we assume that the call to stroke only needs to do enough
		// to correctly generate the CSIM maps.
		// We use this variable to skip things we don't strictly need
		// to do to generate the image map to improve performance
		// a best we can. Therefor you will see a lot of tests !$_csim in the
		// code below.
		$_csim = ($aStrokeFileName===_CSIM_SPECIALFILE);

		// We need to know if we have stroked the plot in the
		// GetCSIMareas. Otherwise the CSIM hasn't been generated
		// and in the case of GetCSIM called before stroke to generate
		// CSIM without storing an image to disk GetCSIM must call Stroke.
		$this->iHasStroked = true;

		//Check if we should autoscale axis
		if( !$this->scale->IsSpecified() && count($this->plots)>0 ) {
			$max = $this->GetPlotsMax();
			$t1 = $this->img->plotwidth;
			$this->img->plotwidth /= 2;
			$t2 = $this->img->left_margin;
			$this->img->left_margin += $this->img->plotwidth+1;
			$this->scale->AutoScale($this->img,0,$max,
			$this->img->plotwidth/$this->xtick_factor/2);
			$this->img->plotwidth = $t1;
			$this->img->left_margin = $t2;
		}
		else {
			// The tick calculation will use the user suplied min/max values to determine
			// the ticks. If auto_ticks is false the exact user specifed min and max
			// values will be used for the scale.
			// If auto_ticks is true then the scale might be slightly adjusted
			// so that the min and max values falls on an even major step.
			//$min = 0;
			$max = $this->scale->scale[1];
			$t1 = $this->img->plotwidth;
			$this->img->plotwidth /= 2;
			$t2 = $this->img->left_margin;
			$this->img->left_margin += $this->img->plotwidth+1;
			$this->scale->AutoScale($this->img,0,$max,
			$this->img->plotwidth/$this->xtick_factor/2);
			$this->img->plotwidth = $t1;
			$this->img->left_margin = $t2;
		}

		if( $this->iType ==  POLAR_180 ) {
			$pos = $this->img->height - $this->img->bottom_margin;
		}
		else {
			$pos = $this->img->plotheight/2 + $this->img->top_margin;
		}

		if( !$_csim ) {
			$this->StrokePlotArea();
		}

		$this->iDoClipping = true;

		if( $this->iDoClipping ) {
			$oldimage = $this->img->CloneCanvasH();
		}

		if( !$_csim ) {
			$this->axis->StrokeGrid($pos);
		}

		// Stroke all plots for Y1 axis
		for($i=0; $i < count($this->plots); ++$i) {
			$this->plots[$i]->Stroke($this->img,$this->scale);
		}


		if( $this->iDoClipping ) {
			// Clipping only supports graphs at 0 and 90 degrees
			if( $this->img->a == 0  ) {
				$this->img->CopyCanvasH($oldimage,$this->img->img,
				$this->img->left_margin,$this->img->top_margin,
				$this->img->left_margin,$this->img->top_margin,
				$this->img->plotwidth+1,$this->img->plotheight+1);
			}
			elseif( $this->img->a == 90 ) {
				$adj1 = round(($this->img->height - $this->img->width)/2);
				$adj2 = round(($this->img->width - $this->img->height)/2);
				$lm = $this->img->left_margin;
				$rm = $this->img->right_margin;
				$tm = $this->img->top_margin;
				$bm = $this->img->bottom_margin;
				$this->img->CopyCanvasH($oldimage,$this->img->img,
				$adj2 + round(($lm-$rm+$tm+$bm)/2),
				$adj1 + round(($tm-$bm+$lm+$rm)/2),
				$adj2 + round(($lm-$rm+$tm+$bm)/2),
				$adj1 + round(($tm-$bm+$lm+$rm)/2),
				$this->img->plotheight+1,
				$this->img->plotwidth+1);
			}
			$this->img->Destroy();
			$this->img->SetCanvasH($oldimage);
		}

		if( !$_csim ) {
			$this->axis->Stroke($pos);
			$this->axis->StrokeAngleLabels($pos,$this->iType);
		}

		if( !$_csim ) {
			$this->StrokePlotBox();
			$this->footer->Stroke($this->img);

			// The titles and legends never gets rotated so make sure
			// that the angle is 0 before stroking them
			$aa = $this->img->SetAngle(0);
			$this->StrokeTitles();
		}

		for($i=0; $i < count($this->plots) ; ++$i ) {
			$this->plots[$i]->Legend($this);
		}

		$this->legend->Stroke($this->img);

		if( !$_csim ) {

			$this->StrokeTexts();
			$this->img->SetAngle($aa);

			// Draw an outline around the image map
			if(_JPG_DEBUG)
			$this->DisplayClientSideaImageMapAreas();

			// If the filename is given as the special "__handle"
			// then the image handler is returned and the image is NOT
			// streamed back
			if( $aStrokeFileName == _IMG_HANDLER ) {
				return $this->img->img;
			}
			else {
				// Finally stream the generated picture
				$this->cache->PutAndStream($this->img,$this->cache_name,$this->inline,$aStrokeFileName);
			}
		}
	}
}



?>
